
//
// Created by lingwu on 2021/8/18.
//#include "time.h"

typedef enum parking{//列举出车位信息
    first=110,second,third,fourth,fifth,sixth,seventh
}Parking_space;
typedef struct parking_information{//定义停在停车场一辆车所包含的信息
//    一辆车的包含信息
    Parking_space space; //所在车位
     int  Parking_time; //停入的时间
    long Car_number;  //车牌号
    bool feel; //缴费标签 false为未缴，true 为己缴费
    bool state; //是否开车标签,即是还在停车场中,true为在停车场，false为不在停车场
//    停车场中车位数量信息（停车场参数信息）
    int Park_sum; //总车位数为7
    int usedParkSum; //己用车位数量
    int unusedParkSum; //未用车位数量
}Park_car_information;
typedef struct spaceTime{
    int year;
    long month;
    long day;
    long hour;
    long minute;
    long second;
}TimeType;

///
// Created by lingwu on 2021/8/21.
//
using namespace std;
#ifndef DEMO_INPUTPARKINGTIMECHECK_H
#define DEMO_INPUTPARKINGTIMECHECK_H

#endif //DEMO_INPUTPARKINGTIMECHECK_H
//对输入停车时间的数据进行检查
bool isPositiveNumber(int con_number){
//    判断数是否为正数（con_number>0）
    return con_number>0;
}
bool isNonnegativeNumber(int con_number){
//    判断数是否为非负数（con_number>=0）
    return con_number>=0;
}
int getMaxNumberOfDaysInThisMonth(int con_month){
//    返回当前月份的最大最值
    switch (con_month) {
        case 2:return 29;
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:return 31;
        case 4:
        case 6:
        case 9:
        case 11:return 30;
    }
}
int getConParkingTimeLength(int inputTime){
//    返回所输入停车时间参数的长度,应为7~8位（7<=input<=8）
int temp=inputTime;
        int length=0;
    while (temp>0){
        temp/=10;
        length++;
    }
    return length;
}
int getInputParkingTimeMonth(int conInputTime){
//    剥离出月份
    return conInputTime/1000000;
}
int getInputParkingTimeDay(int conInputTime){
    //      剥离出天数
    return (conInputTime- getInputParkingTimeMonth(conInputTime)*1000000)/10000;
}
int getInputParkingTimeHour(int conInputTime){
    //      剥离出小时
    return (conInputTime-getInputParkingTimeMonth(conInputTime)*1000000- getInputParkingTimeDay(conInputTime)*10000)/100;
}
int getInputParkingTimeMinute(int conInputTime){
    //      剥离出分钟
    return (conInputTime-getInputParkingTimeMonth(conInputTime)*1000000-getInputParkingTimeDay(conInputTime)*10000)%100;
}
bool monthCheck(int con_parkTime_month){
//    对剥离出来的月份进行检查，范围：1~12（0<con_month<13）
if (isPositiveNumber(con_parkTime_month)&&con_parkTime_month<13)
        return true;
    else
        return false;

}
bool dayCheck(int con_parkTime_day,int inputParkingTimeMonth){
//    对剥离出来的天数进行检查，范围：1~Max（0<con_day<Max）
    if (isPositiveNumber(con_parkTime_day)&&(con_parkTime_day<= getMaxNumberOfDaysInThisMonth(inputParkingTimeMonth)))

        return true;
    else{
        return false;
    }

}
bool hourCheck(int inputParkingTimeHour){
    //    对剥离出来的小时进行检查，范围：0~23（0<=con_hour<=23）
    if (isNonnegativeNumber(inputParkingTimeHour)&&inputParkingTimeHour<=23)
        return true;
    else
        return false;

}
bool minuteCheck(int inputParkingTimeMinute){
    //    对剥离出来的分钟进行检查，范围：0~59（0<=con_minute<60）
    if (isNonnegativeNumber(inputParkingTimeMinute)&&inputParkingTimeMinute<60)
        return true;
    else
        return false;
}
bool wholeCheck(int inputParkingTime){
    //    调用前面的所有检查函数，进行整体性检查,总长度应为7~8位（7<=input<=8）
    if((getConParkingTimeLength(inputParkingTime)==7|| getConParkingTimeLength(inputParkingTime)==8)&& monthCheck(
            getInputParkingTimeMonth(inputParkingTime))&& dayCheck(getInputParkingTimeDay(inputParkingTime), getInputParkingTimeMonth(inputParkingTime))&&
                                                          hourCheck(getInputParkingTimeHour(inputParkingTime))&&
                                                          minuteCheck(getInputParkingTimeMinute(inputParkingTime)))

        return true;
    else
            return false;
    }
    //
// Created by lingwu on 2021/8/21.
//
using namespace std;
#ifndef DEMO_INPUTPARKINGTIMECHECK_H
#define DEMO_INPUTPARKINGTIMECHECK_H

#endif //DEMO_INPUTPARKINGTIMECHECK_H
//对输入停车时间的数据进行检查
bool isPositiveNumber(int con_number){
//    判断数是否为正数（con_number>0）
    return con_number>0;
}
bool isNonnegativeNumber(int con_number){
//    判断数是否为非负数（con_number>=0）
    return con_number>=0;
}
int getMaxNumberOfDaysInThisMonth(int con_month){
//    返回当前月份的最大最值
    switch (con_month) {
        case 2:return 29;
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:return 31;
        case 4:
        case 6:
        case 9:
        case 11:return 30;
    }
}
int getConParkingTimeLength(int inputTime){
//    返回所输入停车时间参数的长度,应为7~8位（7<=input<=8）
int temp=inputTime;
        int length=0;
    while (temp>0){
        temp/=10;
        length++;
    }
    return length;
}
int getInputParkingTimeMonth(int conInputTime){
//    剥离出月份
    return conInputTime/1000000;
}
int getInputParkingTimeDay(int conInputTime){
    //      剥离出天数
    return (conInputTime- getInputParkingTimeMonth(conInputTime)*1000000)/10000;
}
int getInputParkingTimeHour(int conInputTime){
    //      剥离出小时
    return (conInputTime-getInputParkingTimeMonth(conInputTime)*1000000- getInputParkingTimeDay(conInputTime)*10000)/100;
}
int getInputParkingTimeMinute(int conInputTime){
    //      剥离出分钟
    return (conInputTime-getInputParkingTimeMonth(conInputTime)*1000000-getInputParkingTimeDay(conInputTime)*10000)%100;
}
bool monthCheck(int con_parkTime_month){
//    对剥离出来的月份进行检查，范围：1~12（0<con_month<13）
if (isPositiveNumber(con_parkTime_month)&&con_parkTime_month<13)
        return true;
    else
        return false;

}
bool dayCheck(int con_parkTime_day,int inputParkingTimeMonth){
//    对剥离出来的天数进行检查，范围：1~Max（0<con_day<Max）
    if (isPositiveNumber(con_parkTime_day)&&(con_parkTime_day<= getMaxNumberOfDaysInThisMonth(inputParkingTimeMonth)))

        return true;
    else{
        return false;
    }

}
bool hourCheck(int inputParkingTimeHour){
    //    对剥离出来的小时进行检查，范围：0~23（0<=con_hour<=23）
    if (isNonnegativeNumber(inputParkingTimeHour)&&inputParkingTimeHour<=23)
        return true;
    else
        return false;

}
bool minuteCheck(int inputParkingTimeMinute){
    //    对剥离出来的分钟进行检查，范围：0~59（0<=con_minute<60）
    if (isNonnegativeNumber(inputParkingTimeMinute)&&inputParkingTimeMinute<60)
        return true;
    else
        return false;
}
bool wholeCheck(int inputParkingTime){
    //    调用前面的所有检查函数，进行整体性检查,总长度应为7~8位（7<=input<=8）
    if((getConParkingTimeLength(inputParkingTime)==7|| getConParkingTimeLength(inputParkingTime)==8)&& monthCheck(
            getInputParkingTimeMonth(inputParkingTime))&& dayCheck(getInputParkingTimeDay(inputParkingTime), getInputParkingTimeMonth(inputParkingTime))&&
                                                          hourCheck(getInputParkingTimeHour(inputParkingTime))&&
                                                          minuteCheck(getInputParkingTimeMinute(inputParkingTime)))

        return true;
    else
            return false;
    }

    /
// Created by lingwu on 2021/8/19.
//创建运算文件
//#include <iostream>

#include "linklist.h"
#include "time.h"
int disengagedParkSpace[7],wholeParkSpace[7]={110,111,112,113,114,115,116};
void ParameterUpdate(LNode *&lNode,int unused_sum_Add){
//    进行停车场参数更新
    LNode *p=lNode->next,*con_update=p;
    lNode->next->carInformation.Park_sum=7;
    lNode->next->carInformation.usedParkSum=lNode->next->carInformation.usedParkSum-unused_sum_Add;
    lNode->next->carInformation.unusedParkSum=lNode->next->carInformation.unusedParkSum+unused_sum_Add;
    while (p!=lNode){
        p->carInformation.Park_sum=con_update->carInformation.Park_sum;
        p->carInformation.unusedParkSum=con_update->carInformation.unusedParkSum;
        p->carInformation.usedParkSum=con_update->carInformation.usedParkSum;
        p=p->next;
    }
}
void DeleteNode(LNode *&lNode,LNode *toFreeNode){
    LNode *pre,*p=lNode->next;
    while (p!=toFreeNode){
        pre=p;
        p=pre->next;
    }
    if (p==toFreeNode){
        pre->next=toFreeNode->next;
        free(toFreeNode);
    }
//    进行停车场参数更新

    ParameterUpdate(lNode,1);

}
void getNowTime(TimeType &con_time){
//    获取当时间
    time_t t;
    struct tm * lt;
    time(&t);//获取Unix时间戳。
    lt = localtime (&t);//转为时间结构。
    con_time.year=lt->tm_year+1900;
    con_time.month=lt->tm_mon+1;
    con_time.day=lt->tm_mday;
    con_time.hour=lt->tm_hour;
    con_time.minute=lt->tm_min;
    con_time.second=lt->tm_sec;

}
void printfTime(TimeType nowTime){
//    输出当前时间
printf ( "当前时间为：%d/%d/%d %d:%d:%d\n",nowTime.year, nowTime.month, nowTime.day, nowTime.hour, nowTime.minute, nowTime.minute);//输出结果

}
void getParkingTime(LNode *temp,long &monthBySplit,long &dayBySplit,long &hourBySplit,long &minuteBySplit){
//    得到停车时候的时间
monthBySplit=temp->carInformation.Parking_time/1000000; //拆分出月份
dayBySplit=(temp->carInformation.Parking_time-monthBySplit*1000000)/10000;
hourBySplit=(temp->carInformation.Parking_time-monthBySplit*1000000-dayBySplit*10000)/100;
minuteBySplit=(temp->carInformation.Parking_time-monthBySplit*1000000-dayBySplit*10000)%100;
}
bool checkInputSpaceIsEmpty(int spaceNumber){
//    进行检查输入的车位号是停车场空的车位号
bool judgeInputSpaceNumberIsRight(int spaceNumber);
    if (judgeInputSpaceNumberIsRight(spaceNumber))
    {
        for (int i = 0; i <7 ; i++) {
            if (disengagedParkSpace[i]==spaceNumber)
            {
                puts("输入空车位号正确");
//                break;
                return true;
            }

            else
            {
                continue;
                return false;
            }

        }
    }

}
bool checkParkSpace(LNode *lNode){
//    检查是否还有车位，创建数组再扫描循环链表,有则返回true，没有则返回false

    LNode *p=lNode->next;
//    int i=0;
    int temp[7],count=0;
    for (int j = 0; j <7 ; j++) {
//        数组初始化
        temp[j]=wholeParkSpace[j];
        disengagedParkSpace[j]=0;
    }
    while (p!=lNode){
        for (int i = 0; i <7 ; i++) {
            if (p->carInformation.space==temp[i]){
                temp[i]=-1;

            }
        }
        p=p->next;
    }
    for (int x = 0; x <7 ; x++) {
        if (temp[x]!=-1)
        {
            disengagedParkSpace[x]=temp[x];
        }

    }
    for (int y = 0; y <7 ; y++) {
        if (disengagedParkSpace[y]!=0&&disengagedParkSpace[y]!=-1){
            count++;
        }
    }
    if (count>0){

        return true;
    }
    else{
        puts("已经没空车位,正在排队进场停车。请耐心等待！");
        return false;
    }

;
}
void printfParkSpce(LNode *lNode){
//    将空的车位信息进行输出

LNode *p=lNode->next;
//    int i=0;
int temp[7],count=0;
for (int j = 0; j <7 ; j++) {
    //        数组初始化
    temp[j]=wholeParkSpace[j];
    disengagedParkSpace[j]=0;
}
while (p!=lNode){
    for (int i = 0; i <7 ; i++) {
        if (p->carInformation.space==temp[i]){
            temp[i]=-1;

        }
    }
    p=p->next;
}
for (int x = 0; x <7 ; x++) {
    if (temp[x]!=-1)
    {
        disengagedParkSpace[x]=temp[x];
    }

}
for (int y = 0; y <7 ; y++) {
    if (disengagedParkSpace[y]!=0&&disengagedParkSpace[y]!=-1){

        count++;
    }
}
if (count>0){
    cout<<"还有的空车位有："<<count<<"个"<<endl;
    printf("分别为：");
          for (int a = 0;  a<7 ; a++) {
              if (disengagedParkSpace[a]!=0&&disengagedParkSpace[a]!=-1){
                  //            cout<<"dis:"<<disengagedParkSpace[y]<<endl;
                  printf("%d\t",disengagedParkSpace[a]);
                  //                count++;
              }
          }
          puts("\n");
}


puts("\n");

}
//添加只能输入空车位信息限制
bool toStopCar(LNode *&lNode){
//    停车函数，先检查是还有车位，再进行停车，
//    创建结节，插入到循环链表，再进行停车场参数信息覆盖
//     需要进行输入停车位号、车牌号，停车时间
    if (checkParkSpace(lNode)){
        Park_car_information parkCarInformation;
        int parkingTime;
        int SpaceNumber;
        puts("请输入停车信息（包含停车位号、车牌号、停车时间）以空格开隔：");
        puts("停车时间包含月份日期时分，这些是连在一起输入的。如：8月19号14时23分，应输入的是08191423。最前的0可以不写。且都是正整数");

        cin>>SpaceNumber>>parkCarInformation.Car_number>>parkingTime;

        if (checkInputSpaceIsEmpty(SpaceNumber)){
            while (!wholeCheck(parkingTime)){
                puts("输入的时间不对，请重新输入(#｀-_ゝ-)");
                cin>>parkingTime;
            }
            if (wholeCheck(parkingTime))
                parkCarInformation.Parking_time=parkingTime;

            switch (SpaceNumber) {
                case 110:parkCarInformation.space=first;break;
                case 111:parkCarInformation.space=second;break;
                case 112:parkCarInformation.space=third;break;
                case 113:parkCarInformation.space=fourth;break;
                case 114:parkCarInformation.space=fifth;break;
                case 115:parkCarInformation.space=sixth;break;
                case 116:parkCarInformation.space=seventh;break;
            }
            ListInsert(lNode, ListLength(lNode)+1,parkCarInformation);
            ParameterUpdate(lNode,-1);
            return true;
        }
        else
            return false;

    }

}

void feeCollecting(LNode *&lNode,spaceTime now_time,long carNumber){
//    输出系统时间和停车时间，不足一小时按一小时计数，
//    将该车辆信息结节中的fee改为true
    bool findCarByLicense(LNode *lNode,LNode *&findResult,long carNumber);
    LNode *temp;
    long expense,fee,hour=0,monthBySplit,dayBySplit,hourBySplit,minuteBySplit;

    if (findCarByLicense(lNode,temp,carNumber)){

        getParkingTime(temp,monthBySplit,dayBySplit,hourBySplit,minuteBySplit);
        cout<<"停入时间为："<<monthBySplit<<"月"<<dayBySplit<<"日"<<hourBySplit<<"时"<<minuteBySplit<<"分"<<endl;
        puts("tips:按小时收费，每小时3元，没满一小时按小时进行计算；（默认一个月为30天）");
        puts("正在计算中，缴费时输入对应的费用（数字）即可");


        hour= (now_time.month-monthBySplit)*30*24+(now_time.day-dayBySplit)*24+(now_time.hour-hourBySplit);
        if (minuteBySplit!=0){
            expense=hour*3+3;
        }

        else
        expense=hour*3;
        printf("所需费用为%d",expense);
        puts("请缴费");
        cin>>fee;
        if (fee==expense){
            puts("谢谢缴费");
            temp->carInformation.feel= true;
        }
        else{
            puts("缴费失败，请再次操作");
            feeCollecting(lNode,now_time,carNumber);
        }

    }

}

void driveCar(LNode *&lNode,long car_number){
//    开出停车场函数，先检查信息结点中的fee是否为true，再进行开出（改标签先判断标签再进行删除该结节）
bool findCarByLicense(LNode *lNode,LNode *&findResult,long carNumber);
bool GetLastElem(LNode *lNode,Park_car_information &e);
//    long car_number;
    LNode *temp;
    Park_car_information e;
    TimeType time1;
    getNowTime(time1);
   if( findCarByLicense(lNode,temp,car_number)){
       temp->carInformation.state= false;
       if (temp->carInformation.state== false&&temp->carInformation.feel== true){
           DeleteNode(lNode,temp);
           puts("更新后的停车场信息：");
           if (GetLastElem(lNode,e)){

           }
           DispList(lNode);
       }
       else{
           puts("请先进行缴费");
           feeCollecting(lNode,time1,car_number);
           driveCar(lNode,car_number);
       }
   }

}

void fexit(){
//    退出功能函数
    exit(0);
}

bool findCarByLicense(LNode *lNode,LNode *&findResult,long carNumber){
//    通过车牌编号找车

    LNode *p=lNode->next;
    if (p==lNode)
        return false;
    else{
        while (p!=lNode){
            if (p->carInformation.Car_number!=carNumber)
            {
                p=p->next;

            }
            else{
                findResult=p;
                return true;

            }

        }
    }

}
bool findCarBySpace(LNode *lNode,LNode *&findResult,long spaceNumber){
    //    通过停车位找车
    bool judgeInputSpaceNumberIsRight(int spaceNumber);

    LNode *p=lNode->next;
    if (p==lNode)
        return false;
    else{
        if (judgeInputSpaceNumberIsRight(spaceNumber)){
            while (p!=lNode){
                if (p->carInformation.space!=spaceNumber)
                {
                    p=p->next;

                }
                else{
                    findResult=p;
                    return true;

                }

            }
    }
}

}
void printhfACarInfomaton(LNode *lNode){
//  输出一输车的相关信息，包括车位号、停入时间、车牌号、缴费、状态、
//总的车位数、己用车位数、未用车位数
    long month,day,hour,minute;
    getParkingTime(lNode,month,day,hour,minute);
    cout<<"所在车位号为：\t"<<lNode->carInformation.space<<endl;
    cout<<"停入时间为：\t"<<month<<"月"<<day<<"日"<<hour<<"时"<<minute<<"分"<<endl;
    cout<<"车牌号为：\t"<<lNode->carInformation.Car_number<<endl;
    if (lNode->carInformation.feel)
    cout<<"缴费情况：\t"<<"己缴纳"<<endl;
    else
        cout<<"缴费情况：\t"<<"未缴纳"<<endl;
    if (lNode->carInformation.state)
        cout<<"所处状况：\t"<<"还在停车场"<<endl;
    else
        cout<<"所处状况：\t"<<"不在停车场"<<endl;
    cout<<"车位情况：\t"<<"总的车位数："<<lNode->carInformation.Park_sum<<"占用车位数："<<lNode->carInformation.usedParkSum<<"空车位数："<<lNode->carInformation.unusedParkSum<<endl;

}

bool judgeInputCarNumberIsRight(LNode *lNode,long inputCarNumber){
//    对输入的车牌号进行判断是否在停车场中
//    true为输入正确，即在停车场中，false为输入错误，即停车场中没有——输入错误
//    主要用在1. 查询中的通过车牌号查找车辆信息 2.离开停车场输入的车牌信息核对
//     准保输入的号码停在停车场中
    LNode *find=NULL;
    if (findCarByLicense(lNode,find,inputCarNumber)){
        if (find!=NULL)
            return true; //所输入车牌号对应的车，停在停车场中
    }
    else
        return false; //所输入车牌号对应的车，不在停车场中
}
bool judgeInputSpaceNumberIsRight(int spaceNumber){
//    进行检查输入的车位号，且只能在110~116之间
//      true为输入正确，false为输入错误
//     主要用到1. 停车时输入的停车位号检查和2. 离开停车场时车位号检查
//     准保输入的号码是停车场的停车位号
    if (spaceNumber>=110&&spaceNumber<=1116)
        return true;
    else
        return false;

}

//链队运算算法
#include <stdio.h>
#include <malloc.h>
//#include "linklist.h"
//#include <iostream>

//using namespace std;
typedef long  Car_number;
typedef struct DataNode
{	
	Car_number carNumber;
	struct DataNode *next;
} DataNode;				//链队数据结点类型
typedef struct
{	
	DataNode *front;
	DataNode *rear;
} LinkQuNode;			//链队类型
void InitQueue(LinkQuNode *&q)
{	
	q=(LinkQuNode *)malloc(sizeof(LinkQuNode));
	q->front=q->rear=NULL;
}
void DisQueue(LinkQuNode *linkQuNode){
//    输出队列
//    LinkQuNode *p=linkQuNode=linkQuNode;
    DataNode *p= reinterpret_cast<DataNode *>(linkQuNode = reinterpret_cast<LinkQuNode *>(linkQuNode->front));
    while (p!=NULL){
        printf("%d\t",p->carNumber);

        p=p->next;
    }
}
void DestroyQueue(LinkQuNode *&q)
{
	DataNode *p=q->front,*r;//p指向队头数据结点
	if (p!=NULL)			//释放数据结点占用空间
	{	r=p->next;
		while (r!=NULL)
		{	free(p);
			p=r;r=p->next;
		}
	}
	free(p);
	free(q);				//释放链队结点占用空间
}
bool QueueEmpty(LinkQuNode *q)
{
	return(q->rear==NULL);
}
void enQueue(LinkQuNode *&q,Car_number e)
{	DataNode *p;
	p=(DataNode *)malloc(sizeof(DataNode));
	p->carNumber=e;
	p->next=NULL;
	if (q->rear==NULL)		//若链队为空,则新结点是队首结点又是队尾结点
		q->front=q->rear=p;
	else
	{	q->rear->next=p;	//将p结点链到队尾,并将rear指向它
		q->rear=p;
	}
}
bool deQueue(LinkQuNode *&q,Car_number &e)
{	DataNode *t;
	if (q->rear==NULL)		//队列为空
		return false;
	t=q->front;				//t指向第一个数据结点
	if (q->front==q->rear)  //队列中只有一个结点时
		q->front=q->rear=NULL;
	else					//队列中有多个结点时
		q->front=q->front->next;
	e=t->carNumber;
	free(t);
	return true;
}
//
// Created by lingwu on 2021/8/20.
//
#include "liqueue.h"
#ifndef DEMO_LIQUEUOPERATION_H
#define DEMO_LIQUEUOPERATION_H

#endif //DEMO_LIQUEUOPERATION_H

void toStopEnQueue(LinkQuNode *&linkQuNode ,Car_number carNumber){
    //    进停车场入队，出队代表己进入停车场,排队停车
    enQueue(linkQuNode,carNumber);

    if (!QueueEmpty(linkQuNode)){
        puts("正在进行排队");
        puts("排队停车队伍为：");
        DisQueue(linkQuNode);
    }
    puts("\n");


}
void toStopDeQueue(LinkQuNode *&linkQuNode,Car_number &carNumber){
//    出队代表己停入停车场
    puts("有空的车位，请做好准备进行停车");
    deQueue(linkQuNode,carNumber);
}
void leaveEnQueue(LinkQuNode *&linkQuNode,Car_number carNumber){
//  离开队列入队，代表走停车场准备离开
//    InitQueue(linkQuNode);
    puts("己进入离开队伍，马上就可以离开！请耐心等待");
    enQueue(linkQuNode,carNumber);

}
void leaveDeQueue(LinkQuNode *&linkQuNode,Car_number &carNumber){
    //  离开队列出队，代表己离开停车场
    puts("祝您一路顺风！");
    deQueue(linkQuNode,carNumber);
}

//#include <iostream>
//# include "linklist.cpp"
//#include "liqueue.cpp"
//#include "linkOperation.h"
#include "searchAddMenu.h"
//#include "inputParkingTimeCheck.h"
using namespace std;
int main() {
    Park_car_information parkCarInformation[6]={{second,8191220,1},{third,8191220,2},{fourth,8191220,3},{fifth,8191220,4},{sixth,8191220,5},{seventh,8191220,6}};
    LinkNode *linkNode;
    TimeType spaceTime;
    InitList(linkNode);
    CreateListR(linkNode,parkCarInformation,6);
    parkParameterCoverage(linkNode); //运用最后一个结点进行初始化后的停车场信息参数覆盖

    getNowTime(spaceTime);
    printfTime(spaceTime);
    menu(linkNode);


    DestroyList(linkNode);
}


/
// Created by lingwu on 2021/8/20.
//
#include "linkOperation.h"
#include "liqueueOperation.h"
#ifndef DEMO_SEARCHADDMENU_H
#define DEMO_SEARCHADDMENU_H

#endif //DEMO_SEARCHADDMENU_H

void search(LNode *lNode){
    //    查询功能函数，
    //包含找空车位（调用检查车位函数），查看停入车辆的信息（可通过车牌号或停车位编号进行查看——调用两个找车函数然后列信息即可），
    //找车函数分为停车位找车和车牌号找车,找到车并列出信息
//1.找空车位，2.找车（分为两种），3.查看全部停车信息 4.返回菜单
void menu(LNode *&lNode);

    int choice;
    LNode *find;
    long number; //存储临时的车位编号或车牌号
    puts("查询\n\t功能有：1.找空车位，2.找车（分为两种），3.查看全部停车信息，4.返回菜单，5.退出系统 ");
    puts("输入对应功能前面的数字即可");
    cin>>choice;
    if(choice>0&&choice<5){
        while (choice!=5){
            switch (choice) {
                case 1:{
                    //                查找空车位
                    checkParkSpace(lNode);
                    printfParkSpce(lNode);

                }break;
                case 2:{
                    //                进行找车
                    int choose;
                    puts("通过停车位编号查找为1，车牌号查找为2，只用输入对应的数字即可");
                    puts("注意输入格式为：查找编号 数字编号，如（找车位编号为110的相关信息的输入格式为1 110）");
                    cin>>choose>>number;
                    if (choose==1||choose==2){
                        if (choose==1){
//                            通过车位找车
                            findCarBySpace(lNode,find,number);
                            printhfACarInfomaton(find);
                        }
                        else if (choose==2){
//                            通过车牌号找车

                            if (findCarByLicense(lNode,find,number))
                            printhfACarInfomaton(find);
                            else
                            {
//                                输入的车牌编号有误
                                printf("输入的车牌编号有误");
                            }
                        }
                    }
                    else{
                        puts("输入功能编号有误（；?д｀）ゞ！");
                    }
                }break;
                case 3:{
//                    查看全部信息，即遍历停车链表
                    DispList(lNode);
                }break;
                case 4:{
//                    退回菜单，即调用菜单函数
                    menu(lNode);
                }break;

            }
            puts("查询\n\t功能有：1.找空车位，2.找车（分为两种），3.查看全部停车信息，4.返回菜单，5.退出系统 ");
            puts("输入对应功能前面的数字即可");
            cin>>choice;

        }
    }
    if (choice<=0||choice>5){
        //        输入的选择为其它数值
        puts("输入错误重新进行");
        search(lNode);
    }
    if (choice==5)
        fexit();//调用退出函数


}

void menu(LNode *&lNode){
    //    菜单功能函数
    //包含排队，停入停车场（出队），开出，缴费，查询，退出
//    1.代表停车，2.查询，3，离开，4。退出
        int choice;
        LNode *find;
        LinkQuNode *QutoStop,*Quleave; //声明通道队列
        TimeType tempTime; //声明停车时间变量
        Car_number carNumber,tempCarNumber=0; //声明车牌号变量

        InitQueue(QutoStop);
        InitQueue(Quleave);
        puts("菜单\n\t1.停入停车场，2.查询，3缴费，4.离开停车场，5.退出");
        puts("请输入菜单选项（对应功能前的数字即可）");
        cin>>choice;


    if (choice>0&&choice<5){
        while (choice!=5){

            switch (choice) {


                case 1:{
                    //                停车
                    puts("请输入你的车牌号");
                    cin>>carNumber;

                    if(checkParkSpace(lNode)){
                        printfParkSpce(lNode);

                        if (toStopCar(lNode))
                        DispList(lNode);
                    }
                    else{
//                        己没车位进行排队，等待进入停车场

                        toStopEnQueue(QutoStop,carNumber);

                    }
                } break;
                case 2:{
                    //               查询
                    search(lNode);
                }break;
                case 3:{
                    //                缴费
                    puts("请输入需缴费的车牌号：");
                    cin>>carNumber;
                    getNowTime(tempTime);
                    feeCollecting(lNode,tempTime,carNumber);

                }break;
                case 4:{
                    //                离开
                    puts("请输入要离开的车牌号！");
                    cin>>carNumber;
                    if (findCarByLicense(lNode,find,carNumber)){
                        getNowTime(tempTime); //获取当前的时间
                        if (find->carInformation.state) //查看车辆所处状态并进行缴费
                            feeCollecting(lNode,tempTime,carNumber);
                        driveCar(lNode,carNumber);
                        leaveEnQueue(Quleave,carNumber);
                        leaveDeQueue(Quleave,carNumber);
                        printfParkSpce(lNode);

                        if (checkParkSpace(lNode)&& !QueueEmpty(QutoStop)){
                            //判断停车场是否有空，有空车位，则将排队队列进行出队添加到停车循环链表中
                            while (checkParkSpace(lNode)) {
                                toStopDeQueue(QutoStop,tempCarNumber);
                                cout<<"请车牌为"<<tempCarNumber<<"的车主进场停车"<<endl;
                                toStopCar(lNode);
                                if (QueueEmpty(QutoStop))
                                    break;
                            }
//                            while (checkParkSpace(lNode));
                            DispList(lNode);
                        }

                    }
//                    else
                  /*  {
                        //                                输入的车牌编号有误
                        printf("输入的车牌编号有误");
                    }*/


                }break;
            }
            puts("菜单\n\t1.停入停车场，2.查询，3缴费，4.离开停车场，5.退出");
            puts("请输入菜单选项（对应功能前的数字即可）");
            cin>>choice;

        }
    }
    if (choice<=0||choice>5){
//        输入的选择为其它数值
        puts("输入错误重新进行");
        menu(lNode);
    }
    if (choice==5){
        fexit();//调用退出函数
    }
    DestroyQueue(QutoStop);
    DestroyQueue(Quleave);
}